package collection.fanxing;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Box<Integer> box = new Box<>();
        box.setE(100000);
        Integer e = box.getE();
//        System.out.println(e);

        ArrayList<Integer> integers = new ArrayList<>(List.of(1,2,3,4,5,6));
        Integer[] integers1 = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(Arrays.toString(integers1));

        // 当给定的数组长度大于集合的元素个数时，会将size的位置，置为null
        // 小于的话正常拷贝对应位置的元素
        Integer[] integers2 = integers.toArray(integers1);
        System.out.println(Arrays.toString(integers2));
    }


    /**
     * 泛型方法的定义：
     *      在返回值的前面加上<泛型符号>
     *          此时可以在方法的返回值、形式参数列表、以及方法体中使用泛型
     */
    public static <E> E method(E e){
        return e;
    }

    public static void method1(ArrayList<? extends Fu> list){

    }
    public static void method2(ArrayList<? super Fu> list){
        list.add(new Zi());
        list.add(new Fu());
    }
}

class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

/**
 * 如果子类继承泛型类时不指定泛型，则重写方法时默认使用Object
 * 如果子类继承泛型类时将自己也定义成泛型类，重写方法则使用泛型
 * @param <E>
 */
class SonBox<E> extends Box<E>{
    @Override
    public E getE() {
        return super.getE();
    }

    @Override
    public <R> R method(R e) {
        return super.method(e);
    }
}

class Box<E> {
    E e;

    public <R> R method(R e) {
        return e;
    }

    public Box() {
    }

    public Box(E e) {
        this.e = e;
    }

    /**
     * 获取
     * @return e
     */
    public E getE() {
        return e;
    }

    /**
     * 设置
     * @param e
     */
    public void setE(E e) {
        this.e = e;
    }

    public String toString() {
        return "Box{e = " + e + "}";
    }
}
